package com.sqx.modules.goodsType.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.sqx.modules.brand.dao.BrandDao;
import com.sqx.modules.brand.entity.Brand;
import com.sqx.modules.brand.service.BrandService;
import com.sqx.modules.goods.dao.GoodsDao;
import com.sqx.modules.goods.entity.Goods;
import com.sqx.modules.goodsType.entity.GoodsType;
import com.sqx.modules.goodsType.dao.GoodsTypeDao;
import com.sqx.modules.goodsType.service.GoodsTypeService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.sqx.modules.labelType.entity.LabelType;
import com.sqx.modules.labelType.service.LabelTypeService;
import com.sqx.modules.search.service.SearchRecordService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import com.sqx.common.utils.Result;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.springframework.beans.factory.annotation.Autowired;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 商品分类 服务实现类
 *
 * @author wuChang
 * @since 2024-05-30
 */
@Service
public class GoodsTypeServiceImp extends ServiceImpl<GoodsTypeDao, GoodsType> implements GoodsTypeService {
    @Autowired
    private LabelTypeService labelTypeService;
    @Autowired
    private BrandService brandService;
    @Autowired
    private SearchRecordService searchRecordService;
    @Autowired
    private GoodsDao goodsDao;
    @Autowired
    private BrandDao brandDao;

    @Override
    public Result saveGoodsType(GoodsType goodsType) {
        if (goodsType.getLabelId() != null) {
            LabelType labelType = labelTypeService.getById(goodsType.getLabelId());
            if (labelType == null) {
                return Result.error("所选标签分类不存在");
            }
        }
        if (goodsType.getParentId() != null && goodsType.getParentId() != 0) {
            GoodsType parentGoodType = baseMapper.selectById(goodsType.getParentId());
            if (parentGoodType == null) {
                return Result.error("上级不存在");
            }
        }
        if (goodsType.getTypeId() != null) {
            return Result.upStatus(baseMapper.updateById(goodsType));
        } else {
            goodsType.setCreateTime(LocalDateTime.now());
            return Result.upStatus(baseMapper.insert(goodsType));
        }
    }

    @Override
    public IPage<GoodsType> getGoodsTypeList(Integer page, Integer limit, GoodsType goodsType) {
        Page<GoodsType> pages;
        if (page != null && limit != null) {
            pages = new Page<>(page, limit);
        } else {
            pages = new Page<>();
            pages.setSize(-1);
        }
        IPage<GoodsType> iPage = baseMapper.selectPage(pages, new QueryWrapper<>(goodsType)
                .orderByAsc("sort"));
        for (GoodsType record : iPage.getRecords()) {
            LabelType labelType = labelTypeService.getById(record.getLabelId());
            if (labelType != null) {
                record.setLabelName(labelType.getLabel());
            }
        }
        return iPage;
    }

    @Override
    public List<GoodsType> getAppGoodsTypeList(Long labelId, String typeName) {
        List<GoodsType> goodsTypes = baseMapper.selectList(new QueryWrapper<GoodsType>().eq("is_enable", 1)
                .eq(labelId != null, "label_id", labelId)
                .like(typeName != null && !typeName.isEmpty(), "type_name", typeName));
        System.out.println("查询到的商品类型列表：" + goodsTypes);
        List<GoodsType> goodsTypeList = goodsTypes.stream()
                .filter(e -> e.getParentId() == 0)
                .peek((menu) -> {
                    menu.setGoodsTypeList(getChildrenList(menu, goodsTypes));
                    if (menu.getTypeName().contains("手机")) {
                        List<Brand> brands = brandService.getBrandsByLabelId(menu.getLabelId());
                        menu.setBrands(brands);
                        menu.setGoodsTypeList(null);
                    } else if (menu.getTypeName().contains("其他类")) {
                        List<Goods> goodsList = goodsDao.selectList(new QueryWrapper<Goods>()
                                .eq("label_id", menu.getLabelId())
                                .eq("status", 1)
                                .eq("is_enable", 1));
                        menu.setGoodsList(goodsList);
                        menu.setGoodsTypeList(getChildrenList(menu, goodsTypes));
                    }
                })
                .collect(Collectors.toList());
        return goodsTypeList;
    }


    private GoodsType getTopLevelParent(GoodsType goodsType, List<GoodsType> allGoodsTypes) {
        if (goodsType == null || goodsType.getParentId() == 0) {
            return goodsType;
        }

        // 查找父级节点
        Optional<GoodsType> parentOptional = allGoodsTypes.stream()
                .filter(gt -> gt.getTypeId().equals(goodsType.getParentId()))
                .findFirst();

        if (parentOptional.isPresent()) {
            // 递归查找顶级父节点
            return getTopLevelParent(parentOptional.get(), allGoodsTypes);
        }

        // 如果在当前列表中找不到父节点，从数据库中获取
        return baseMapper.selectById(goodsType.getParentId());
    }

    @Override
    public List<GoodsType> getAppGoodsTypeListByName(Long labelId, String typeName, Long userId) {
        // 查询所有符合条件的商品类型数据
        List<GoodsType> allGoodsTypes = baseMapper.selectList(new QueryWrapper<GoodsType>()
                .eq("is_enable", 1)
                .eq(labelId != null, "label_id", labelId)
                .like(StringUtils.isNotBlank(typeName), "type_name", '%' + typeName + '%'));
        if (allGoodsTypes.isEmpty()) {
            List<Brand> brands = brandDao.selectList(new QueryWrapper<Brand>()
                    .like(StringUtils.isNotBlank(typeName), "brand_name", '%' + typeName + '%'));
            if (brands == null) {
                return Collections.EMPTY_LIST;
            }
            for (Brand brand : brands) {
                List<GoodsType> goodsTypeList = baseMapper.selectList(new QueryWrapper<GoodsType>()
                        .eq("label_id", brand.getLabelId())
                        .eq("is_enable", 1));
                if (goodsTypeList != null && !goodsTypeList.isEmpty()) {
//                    GoodsType firstGoodsType = goodsTypeList;
                    for (GoodsType goodsType : goodsTypeList) {
                        if (goodsType.getParentId() == 0 && goodsType.getTypeName().contains("手机")) {
                            List<Brand> brands1 = brandService.getBrandsByLabelId(goodsType.getLabelId());
                            goodsType.setBrands(brands);
                            goodsType.setGoodsTypeList(null);
                            return Collections.singletonList(goodsType);
                        }
                    }
//                    if (firstGoodsType != null && firstGoodsType.getParentId() == 0){
//                        if (firstGoodsType.getTypeName().contains("手机"))
//                        List<Brand> brands1 = brandService.getBrandsByLabelId(firstGoodsType.getLabelId());
//                        firstGoodsType.setBrands(brands);
//                        firstGoodsType.setGoodsTypeList(null);
//                    }
//                    for (GoodsType goodsType : goodsTypeList) {
//                    List<Brand> brands1 = brandService.getBrandsByLabelId(firstGoodsType.getLabelId());
//                    firstGoodsType.setBrands(brands);
//                    firstGoodsType.setGoodsTypeList(null);
//                    }
                }
            }
        } else {
            for (GoodsType allGoodsType : allGoodsTypes) {
                if (allGoodsType.getParentId() == 0 && allGoodsType.getTypeName().contains("手机")) {
                    List<Brand> brands = brandService.getBrandsByLabelId(allGoodsType.getLabelId());
                    allGoodsType.setBrands(brands);
                    allGoodsType.setGoodsTypeList(null);
                } else {
                    GoodsType topLevelParent = getTopLevelParent(allGoodsType, allGoodsTypes);
                    if (topLevelParent != null) {
                        List<Brand> brandsForGoodsType = brandService.getBrandsByLabelId(topLevelParent.getLabelId());
                        if (brandsForGoodsType != null) {
                            for (Brand brand : brandsForGoodsType) {
                                if (brand.getBrandName().contains(typeName) && brand.getLabelId().equals(topLevelParent.getLabelId())) {
                                    topLevelParent.setBrands(Collections.singletonList(brand));
                                    topLevelParent.setGoodsTypeList(null);
                                    return Collections.singletonList(topLevelParent);
                                }
                            }
                        }
                    }
                }
            }
        }
        if (userId != null) {
            searchRecordService.saveRecordInfo(typeName, userId);
        }
        List<GoodsType> result = new ArrayList<>();
        for (GoodsType allGoodsType : allGoodsTypes) {
            if (allGoodsType.getParentId() == 0) {
                if (allGoodsType.getTypeName().contains("手机")) {
                    List<Brand> brands = brandService.getBrandsByLabelId(allGoodsType.getLabelId());
                    allGoodsType.setBrands(brands);
                    allGoodsType.setGoodsTypeList(null);
                } else {
                    // 获取所有符合条件的商品类型的 label_id
                    Long finalLabelId = allGoodsTypes.get(0).getLabelId();
                    List<GoodsType> allGoodsTypeList = baseMapper.selectList(new QueryWrapper<GoodsType>().eq("label_id", finalLabelId));
                    allGoodsType.setGoodsTypeList(getChildrenLists(allGoodsType, allGoodsTypeList, result));
                }
            } else {
                if (allGoodsType.getParentId() != 0) {
                    GoodsType parent = baseMapper.selectById(allGoodsType.getParentId());
//                    allGoodsType.setGoodsTypeList(getChildrenList(allGoodsType, allGoodsTypes));
                    parent.setGoodsTypeList(allGoodsTypes);
                    return Collections.singletonList(parent);
                }
            }
        }
        return allGoodsTypes;
//        // 构建完整的树形结构，并收集符合条件的节点及其子节点
//        List<GoodsType> result = new ArrayList<>();
//        Map<Long, GoodsType> typeMap = allGoodsTypes.stream()
//                .collect(Collectors.toMap(GoodsType::getTypeId, goodsType -> goodsType));
//        // 用于存储所有父节点
//        List<GoodsType> rootNodes = new ArrayList<>();
//        // 遍历所有商品类型数据，构建树形结构
//        for (GoodsType goodsType : allGoodsTypes) {
//            if (goodsType.getParentId() == 0) {
//                // 如果是父节点，则直接加入到结果列表中
//                rootNodes.add(goodsType);
//                getChildrenLists(goodsType, allGoodsTypes, result);
//            } else {
//                // 如果是子节点，则添加到其父节点的子节点列表中
//                GoodsType parent = typeMap.get(goodsType.getParentId());
//                if (parent != null) {
//                    if (parent.getGoodsTypeList() == null) {
//                        parent.setGoodsTypeList(new ArrayList<>());
//                    }
//                    parent.getGoodsTypeList().add(goodsType);
//                }
//            }
//        }
//
//        // 将所有父节点加入最终结果
//        result.addAll(rootNodes);
//        // 返回最终结果
//        System.out.println("查询到的商品类型列表：" + result);
//        return result;
    }

    @Override
    public IPage<GoodsType> getGoodsTypeListByParentId(Integer page, Integer limit) {
        Page<GoodsType> pages;
        if (page != null && limit != null) {
            pages = new Page<>(page, limit);
        } else {
            pages = new Page<>();
            pages.setSize(-1);
        }
        IPage<GoodsType> goodsTypeList = baseMapper.selectPage(pages,new QueryWrapper<GoodsType>()
                .eq("parent_id", 0)
                .eq("is_recovery", 0));
        return goodsTypeList;
    }

    @Override
    public IPage<GoodsType> getGoodsTypeListByChild(Integer page, Integer limit, Long typeId) {
        Page<GoodsType> pages;
        if (page != null && limit != null) {
            pages = new Page<>(page, limit);
        } else {
            pages = new Page<>();
            pages.setSize(-1);
        }
        IPage<GoodsType> goodsTypeList = baseMapper.selectPage(pages,new QueryWrapper<GoodsType>()
                .eq("parent_id", typeId));
        return goodsTypeList;
    }

    private List<GoodsType> getChildrenLists(GoodsType goodsType, List<GoodsType> all, List<GoodsType> result) {
        List<GoodsType> children = all.stream()
                .filter(categoryEntity -> categoryEntity.getParentId().equals(goodsType.getTypeId()))
                .sorted(Comparator.comparing(GoodsType::getSort))
                .peek(categoryEntity -> {
                    // 递归查找子节点
                    getChildrenLists(categoryEntity, all, result);
                })
                .collect(Collectors.toList());

        // 将子节点加入到结果列表中
        result.addAll(children);

        // 设置子节点列表
        goodsType.setGoodsTypeList(children);
        return result;
    }


    //递归查找所有菜单的子菜单
    private List<GoodsType> getChildrenList(GoodsType goodsType, List<GoodsType> all) {
        return all.stream().filter(categoryEntity ->
                        categoryEntity.getParentId().equals(goodsType.getTypeId())).sorted(Comparator.comparing(GoodsType::getSort))
                .peek(categoryEntity -> {
                    //1、找到子菜单(递归)
                    categoryEntity.setGoodsTypeList(getChildrenList(categoryEntity, all));
                }).collect(Collectors.toList());
    }
}
